﻿using System;
using System.Diagnostics;
using System.IO;
using Google.ProtocolBuffers;
using Google.ProtocolBuffers.Descriptors;
using Google.ProtocolBuffers.FieldAccess;

namespace com.gexin.rp.sdk.dto
{
	// Token: 0x02000019 RID: 25
	[DebuggerNonUserCode]
	public sealed class OSMessage : GeneratedMessage<OSMessage, OSMessage.Builder>
	{
		// Token: 0x0600027F RID: 639 RVA: 0x00005F86 File Offset: 0x00004186
		private OSMessage()
		{
		}

		// Token: 0x17000107 RID: 263
		// (get) Token: 0x06000280 RID: 640 RVA: 0x00005FA8 File Offset: 0x000041A8
		public static OSMessage DefaultInstance
		{
			get
			{
				return OSMessage.defaultInstance;
			}
		}

		// Token: 0x17000108 RID: 264
		// (get) Token: 0x06000281 RID: 641 RVA: 0x00005FAF File Offset: 0x000041AF
		public override OSMessage DefaultInstanceForType
		{
			get
			{
				return OSMessage.DefaultInstance;
			}
		}

		// Token: 0x17000109 RID: 265
		// (get) Token: 0x06000282 RID: 642 RVA: 0x00002579 File Offset: 0x00000779
		protected override OSMessage ThisMessage
		{
			get
			{
				return this;
			}
		}

		// Token: 0x1700010A RID: 266
		// (get) Token: 0x06000283 RID: 643 RVA: 0x00005FB6 File Offset: 0x000041B6
		public static MessageDescriptor Descriptor
		{
			get
			{
				return GtReq.internal__static_com_gexin_rp_sdk_dto_OSMessage__Descriptor;
			}
		}

		// Token: 0x1700010B RID: 267
		// (get) Token: 0x06000284 RID: 644 RVA: 0x00005FBD File Offset: 0x000041BD
		protected override FieldAccessorTable<OSMessage, OSMessage.Builder> InternalFieldAccessors
		{
			get
			{
				return GtReq.internal__static_com_gexin_rp_sdk_dto_OSMessage__FieldAccessorTable;
			}
		}

		// Token: 0x1700010C RID: 268
		// (get) Token: 0x06000285 RID: 645 RVA: 0x00005FC4 File Offset: 0x000041C4
		public bool HasIsOffline
		{
			get
			{
				return this.hasIsOffline;
			}
		}

		// Token: 0x1700010D RID: 269
		// (get) Token: 0x06000286 RID: 646 RVA: 0x00005FCC File Offset: 0x000041CC
		public bool IsOffline
		{
			get
			{
				return this.isOffline_;
			}
		}

		// Token: 0x1700010E RID: 270
		// (get) Token: 0x06000287 RID: 647 RVA: 0x00005FD4 File Offset: 0x000041D4
		public bool HasOfflineExpireTime
		{
			get
			{
				return this.hasOfflineExpireTime;
			}
		}

		// Token: 0x1700010F RID: 271
		// (get) Token: 0x06000288 RID: 648 RVA: 0x00005FDC File Offset: 0x000041DC
		public long OfflineExpireTime
		{
			get
			{
				return this.offlineExpireTime_;
			}
		}

		// Token: 0x17000110 RID: 272
		// (get) Token: 0x06000289 RID: 649 RVA: 0x00005FE4 File Offset: 0x000041E4
		public bool HasTransparent
		{
			get
			{
				return this.hasTransparent;
			}
		}

		// Token: 0x17000111 RID: 273
		// (get) Token: 0x0600028A RID: 650 RVA: 0x00005FEC File Offset: 0x000041EC
		public Transparent Transparent
		{
			get
			{
				return this.transparent_ ?? Transparent.DefaultInstance;
			}
		}

		// Token: 0x17000112 RID: 274
		// (get) Token: 0x0600028B RID: 651 RVA: 0x00005FFD File Offset: 0x000041FD
		public bool HasExtraData
		{
			get
			{
				return this.hasExtraData;
			}
		}

		// Token: 0x17000113 RID: 275
		// (get) Token: 0x0600028C RID: 652 RVA: 0x00006005 File Offset: 0x00004205
		public string ExtraData
		{
			get
			{
				return this.extraData_;
			}
		}

		// Token: 0x17000114 RID: 276
		// (get) Token: 0x0600028D RID: 653 RVA: 0x0000600D File Offset: 0x0000420D
		public bool HasMsgType
		{
			get
			{
				return this.hasMsgType;
			}
		}

		// Token: 0x17000115 RID: 277
		// (get) Token: 0x0600028E RID: 654 RVA: 0x00006015 File Offset: 0x00004215
		public int MsgType
		{
			get
			{
				return this.msgType_;
			}
		}

		// Token: 0x17000116 RID: 278
		// (get) Token: 0x0600028F RID: 655 RVA: 0x0000601D File Offset: 0x0000421D
		public bool HasMsgTraceFlag
		{
			get
			{
				return this.hasMsgTraceFlag;
			}
		}

		// Token: 0x17000117 RID: 279
		// (get) Token: 0x06000290 RID: 656 RVA: 0x00006025 File Offset: 0x00004225
		public int MsgTraceFlag
		{
			get
			{
				return this.msgTraceFlag_;
			}
		}

		// Token: 0x17000118 RID: 280
		// (get) Token: 0x06000291 RID: 657 RVA: 0x0000602D File Offset: 0x0000422D
		public bool HasPriority
		{
			get
			{
				return this.hasPriority;
			}
		}

		// Token: 0x17000119 RID: 281
		// (get) Token: 0x06000292 RID: 658 RVA: 0x00006035 File Offset: 0x00004235
		public int Priority
		{
			get
			{
				return this.priority_;
			}
		}

		// Token: 0x1700011A RID: 282
		// (get) Token: 0x06000293 RID: 659 RVA: 0x0000603D File Offset: 0x0000423D
		public override bool IsInitialized
		{
			get
			{
				return this.hasIsOffline && this.hasOfflineExpireTime && (!this.HasTransparent || this.Transparent.IsInitialized);
			}
		}

		// Token: 0x06000294 RID: 660 RVA: 0x0000606C File Offset: 0x0000426C
		public override void WriteTo(ICodedOutputStream output)
		{
			this.CalcSerializedSize();
			string[] oSMessageFieldNames = OSMessage._oSMessageFieldNames;
			if (this.hasIsOffline)
			{
				output.WriteBool(2, oSMessageFieldNames[1], this.IsOffline);
			}
			if (this.hasOfflineExpireTime)
			{
				output.WriteInt64(3, oSMessageFieldNames[4], this.OfflineExpireTime);
			}
			if (this.hasTransparent)
			{
				output.WriteMessage(4, oSMessageFieldNames[6], this.Transparent);
			}
			if (this.hasExtraData)
			{
				output.WriteString(5, oSMessageFieldNames[0], this.ExtraData);
			}
			if (this.hasMsgType)
			{
				output.WriteInt32(6, oSMessageFieldNames[3], this.MsgType);
			}
			if (this.hasMsgTraceFlag)
			{
				output.WriteInt32(7, oSMessageFieldNames[2], this.MsgTraceFlag);
			}
			if (this.hasPriority)
			{
				output.WriteInt32(8, oSMessageFieldNames[5], this.Priority);
			}
			this.UnknownFields.WriteTo(output);
		}

		// Token: 0x1700011B RID: 283
		// (get) Token: 0x06000295 RID: 661 RVA: 0x0000613C File Offset: 0x0000433C
		public override int SerializedSize
		{
			get
			{
				int num = this.memoizedSerializedSize;
				if (num != -1)
				{
					return num;
				}
				return this.CalcSerializedSize();
			}
		}

		// Token: 0x06000296 RID: 662 RVA: 0x0000615C File Offset: 0x0000435C
		private int CalcSerializedSize()
		{
			int num = this.memoizedSerializedSize;
			if (num != -1)
			{
				return num;
			}
			num = 0;
			if (this.hasIsOffline)
			{
				num += CodedOutputStream.ComputeBoolSize(2, this.IsOffline);
			}
			if (this.hasOfflineExpireTime)
			{
				num += CodedOutputStream.ComputeInt64Size(3, this.OfflineExpireTime);
			}
			if (this.hasTransparent)
			{
				num += CodedOutputStream.ComputeMessageSize(4, this.Transparent);
			}
			if (this.hasExtraData)
			{
				num += CodedOutputStream.ComputeStringSize(5, this.ExtraData);
			}
			if (this.hasMsgType)
			{
				num += CodedOutputStream.ComputeInt32Size(6, this.MsgType);
			}
			if (this.hasMsgTraceFlag)
			{
				num += CodedOutputStream.ComputeInt32Size(7, this.MsgTraceFlag);
			}
			if (this.hasPriority)
			{
				num += CodedOutputStream.ComputeInt32Size(8, this.Priority);
			}
			num += this.UnknownFields.SerializedSize;
			this.memoizedSerializedSize = num;
			return num;
		}

		// Token: 0x06000297 RID: 663 RVA: 0x0000622F File Offset: 0x0000442F
		public static OSMessage ParseFrom(ByteString data)
		{
			return OSMessage.CreateBuilder().MergeFrom(data).BuildParsed();
		}

		// Token: 0x06000298 RID: 664 RVA: 0x00006241 File Offset: 0x00004441
		public static OSMessage ParseFrom(ByteString data, ExtensionRegistry extensionRegistry)
		{
			return OSMessage.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed();
		}

		// Token: 0x06000299 RID: 665 RVA: 0x00006254 File Offset: 0x00004454
		public static OSMessage ParseFrom(byte[] data)
		{
			return OSMessage.CreateBuilder().MergeFrom(data).BuildParsed();
		}

		// Token: 0x0600029A RID: 666 RVA: 0x00006266 File Offset: 0x00004466
		public static OSMessage ParseFrom(byte[] data, ExtensionRegistry extensionRegistry)
		{
			return OSMessage.CreateBuilder().MergeFrom(data, extensionRegistry).BuildParsed();
		}

		// Token: 0x0600029B RID: 667 RVA: 0x00006279 File Offset: 0x00004479
		public static OSMessage ParseFrom(Stream input)
		{
			return OSMessage.CreateBuilder().MergeFrom(input).BuildParsed();
		}

		// Token: 0x0600029C RID: 668 RVA: 0x0000628B File Offset: 0x0000448B
		public static OSMessage ParseFrom(Stream input, ExtensionRegistry extensionRegistry)
		{
			return OSMessage.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x0600029D RID: 669 RVA: 0x0000629E File Offset: 0x0000449E
		public static OSMessage ParseDelimitedFrom(Stream input)
		{
			return OSMessage.CreateBuilder().MergeDelimitedFrom(input).BuildParsed();
		}

		// Token: 0x0600029E RID: 670 RVA: 0x000062B0 File Offset: 0x000044B0
		public static OSMessage ParseDelimitedFrom(Stream input, ExtensionRegistry extensionRegistry)
		{
			return OSMessage.CreateBuilder().MergeDelimitedFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x0600029F RID: 671 RVA: 0x000062C3 File Offset: 0x000044C3
		public static OSMessage ParseFrom(ICodedInputStream input)
		{
			return OSMessage.CreateBuilder().MergeFrom(input).BuildParsed();
		}

		// Token: 0x060002A0 RID: 672 RVA: 0x000062D5 File Offset: 0x000044D5
		public static OSMessage ParseFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
		{
			return OSMessage.CreateBuilder().MergeFrom(input, extensionRegistry).BuildParsed();
		}

		// Token: 0x060002A1 RID: 673 RVA: 0x00002579 File Offset: 0x00000779
		private OSMessage MakeReadOnly()
		{
			return this;
		}

		// Token: 0x060002A2 RID: 674 RVA: 0x000062E8 File Offset: 0x000044E8
		public static OSMessage.Builder CreateBuilder()
		{
			return new OSMessage.Builder();
		}

		// Token: 0x060002A3 RID: 675 RVA: 0x000062EF File Offset: 0x000044EF
		public override OSMessage.Builder ToBuilder()
		{
			return OSMessage.CreateBuilder(this);
		}

		// Token: 0x060002A4 RID: 676 RVA: 0x000062E8 File Offset: 0x000044E8
		public override OSMessage.Builder CreateBuilderForType()
		{
			return new OSMessage.Builder();
		}

		// Token: 0x060002A5 RID: 677 RVA: 0x000062F7 File Offset: 0x000044F7
		public static OSMessage.Builder CreateBuilder(OSMessage prototype)
		{
			return new OSMessage.Builder(prototype);
		}

		// Token: 0x060002A6 RID: 678 RVA: 0x00006300 File Offset: 0x00004500
		static OSMessage()
		{
			FileDescriptor descriptor = GtReq.Descriptor;
		}

		// Token: 0x04000154 RID: 340
		private static readonly OSMessage defaultInstance = new OSMessage().MakeReadOnly();

		// Token: 0x04000155 RID: 341
		private static readonly string[] _oSMessageFieldNames = new string[]
		{
			"extraData",
			"isOffline",
			"msgTraceFlag",
			"msgType",
			"offlineExpireTime",
			"priority",
			"transparent"
		};

		// Token: 0x04000156 RID: 342
		private static readonly uint[] _oSMessageFieldTags = new uint[]
		{
			42u,
			16u,
			56u,
			48u,
			24u,
			64u,
			34u
		};

		// Token: 0x04000157 RID: 343
		public const int IsOfflineFieldNumber = 2;

		// Token: 0x04000158 RID: 344
		private bool hasIsOffline;

		// Token: 0x04000159 RID: 345
		private bool isOffline_;

		// Token: 0x0400015A RID: 346
		public const int OfflineExpireTimeFieldNumber = 3;

		// Token: 0x0400015B RID: 347
		private bool hasOfflineExpireTime;

		// Token: 0x0400015C RID: 348
		private long offlineExpireTime_ = 1L;

		// Token: 0x0400015D RID: 349
		public const int TransparentFieldNumber = 4;

		// Token: 0x0400015E RID: 350
		private bool hasTransparent;

		// Token: 0x0400015F RID: 351
		private Transparent transparent_;

		// Token: 0x04000160 RID: 352
		public const int ExtraDataFieldNumber = 5;

		// Token: 0x04000161 RID: 353
		private bool hasExtraData;

		// Token: 0x04000162 RID: 354
		private string extraData_ = "";

		// Token: 0x04000163 RID: 355
		public const int MsgTypeFieldNumber = 6;

		// Token: 0x04000164 RID: 356
		private bool hasMsgType;

		// Token: 0x04000165 RID: 357
		private int msgType_;

		// Token: 0x04000166 RID: 358
		public const int MsgTraceFlagFieldNumber = 7;

		// Token: 0x04000167 RID: 359
		private bool hasMsgTraceFlag;

		// Token: 0x04000168 RID: 360
		private int msgTraceFlag_;

		// Token: 0x04000169 RID: 361
		public const int PriorityFieldNumber = 8;

		// Token: 0x0400016A RID: 362
		private bool hasPriority;

		// Token: 0x0400016B RID: 363
		private int priority_;

		// Token: 0x0400016C RID: 364
		private int memoizedSerializedSize = -1;

		// Token: 0x02000066 RID: 102
		[DebuggerNonUserCode]
		public sealed class Builder : GeneratedBuilder<OSMessage, OSMessage.Builder>
		{
			// Token: 0x17000346 RID: 838
			// (get) Token: 0x06000829 RID: 2089 RVA: 0x00002579 File Offset: 0x00000779
			protected override OSMessage.Builder ThisBuilder
			{
				get
				{
					return this;
				}
			}

			// Token: 0x0600082A RID: 2090 RVA: 0x000134AA File Offset: 0x000116AA
			public Builder()
			{
				this.result = OSMessage.DefaultInstance;
				this.resultIsReadOnly = true;
			}

			// Token: 0x0600082B RID: 2091 RVA: 0x000134C4 File Offset: 0x000116C4
			internal Builder(OSMessage cloneFrom)
			{
				this.result = cloneFrom;
				this.resultIsReadOnly = true;
			}

			// Token: 0x0600082C RID: 2092 RVA: 0x000134DC File Offset: 0x000116DC
			private OSMessage PrepareBuilder()
			{
				if (this.resultIsReadOnly)
				{
					OSMessage other = this.result;
					this.result = new OSMessage();
					this.resultIsReadOnly = false;
					this.MergeFrom(other);
				}
				return this.result;
			}

			// Token: 0x17000347 RID: 839
			// (get) Token: 0x0600082D RID: 2093 RVA: 0x00013518 File Offset: 0x00011718
			public override bool IsInitialized
			{
				get
				{
					return this.result.IsInitialized;
				}
			}

			// Token: 0x17000348 RID: 840
			// (get) Token: 0x0600082E RID: 2094 RVA: 0x00013525 File Offset: 0x00011725
			protected override OSMessage MessageBeingBuilt
			{
				get
				{
					return this.PrepareBuilder();
				}
			}

			// Token: 0x0600082F RID: 2095 RVA: 0x0001352D File Offset: 0x0001172D
			public override OSMessage.Builder Clear()
			{
				this.result = OSMessage.DefaultInstance;
				this.resultIsReadOnly = true;
				return this;
			}

			// Token: 0x06000830 RID: 2096 RVA: 0x00013542 File Offset: 0x00011742
			public override OSMessage.Builder Clone()
			{
				if (this.resultIsReadOnly)
				{
					return new OSMessage.Builder(this.result);
				}
				return new OSMessage.Builder().MergeFrom(this.result);
			}

			// Token: 0x17000349 RID: 841
			// (get) Token: 0x06000831 RID: 2097 RVA: 0x00013568 File Offset: 0x00011768
			public override MessageDescriptor DescriptorForType
			{
				get
				{
					return OSMessage.Descriptor;
				}
			}

			// Token: 0x1700034A RID: 842
			// (get) Token: 0x06000832 RID: 2098 RVA: 0x00005FAF File Offset: 0x000041AF
			public override OSMessage DefaultInstanceForType
			{
				get
				{
					return OSMessage.DefaultInstance;
				}
			}

			// Token: 0x06000833 RID: 2099 RVA: 0x0001356F File Offset: 0x0001176F
			public override OSMessage BuildPartial()
			{
				if (this.resultIsReadOnly)
				{
					return this.result;
				}
				this.resultIsReadOnly = true;
				return this.result.MakeReadOnly();
			}

			// Token: 0x06000834 RID: 2100 RVA: 0x00013592 File Offset: 0x00011792
			public override OSMessage.Builder MergeFrom(IMessage other)
			{
				if (other is OSMessage)
				{
					return this.MergeFrom((OSMessage)other);
				}
				base.MergeFrom(other);
				return this;
			}

			// Token: 0x06000835 RID: 2101 RVA: 0x000135B4 File Offset: 0x000117B4
			public override OSMessage.Builder MergeFrom(OSMessage other)
			{
				if (other == OSMessage.DefaultInstance)
				{
					return this;
				}
				this.PrepareBuilder();
				if (other.HasIsOffline)
				{
					this.IsOffline = other.IsOffline;
				}
				if (other.HasOfflineExpireTime)
				{
					this.OfflineExpireTime = other.OfflineExpireTime;
				}
				if (other.HasTransparent)
				{
					this.MergeTransparent(other.Transparent);
				}
				if (other.HasExtraData)
				{
					this.ExtraData = other.ExtraData;
				}
				if (other.HasMsgType)
				{
					this.MsgType = other.MsgType;
				}
				if (other.HasMsgTraceFlag)
				{
					this.MsgTraceFlag = other.MsgTraceFlag;
				}
				if (other.HasPriority)
				{
					this.Priority = other.Priority;
				}
				this.MergeUnknownFields(other.UnknownFields);
				return this;
			}

			// Token: 0x06000836 RID: 2102 RVA: 0x0001366D File Offset: 0x0001186D
			public override OSMessage.Builder MergeFrom(ICodedInputStream input)
			{
				return this.MergeFrom(input, ExtensionRegistry.Empty);
			}

			// Token: 0x06000837 RID: 2103 RVA: 0x0001367C File Offset: 0x0001187C
			public override OSMessage.Builder MergeFrom(ICodedInputStream input, ExtensionRegistry extensionRegistry)
			{
				this.PrepareBuilder();
				UnknownFieldSet.Builder builder = null;
				uint num;
				string text;
				while (input.ReadTag(out num, out text))
				{
					if (num == 0u && text != null)
					{
						int num2 = Array.BinarySearch<string>(OSMessage._oSMessageFieldNames, text, StringComparer.Ordinal);
						if (num2 < 0)
						{
							if (builder == null)
							{
								builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
							}
							this.ParseUnknownField(input, builder, extensionRegistry, num, text);
							continue;
						}
						num = OSMessage._oSMessageFieldTags[num2];
					}
					if (num <= 34u)
					{
						if (num <= 16u)
						{
							if (num == 0u)
							{
								throw InvalidProtocolBufferException.InvalidTag();
							}
							if (num == 16u)
							{
								this.result.hasIsOffline = input.ReadBool(ref this.result.isOffline_);
								continue;
							}
						}
						else
						{
							if (num == 24u)
							{
								this.result.hasOfflineExpireTime = input.ReadInt64(ref this.result.offlineExpireTime_);
								continue;
							}
							if (num == 34u)
							{
								Transparent.Builder builder2 = Transparent.CreateBuilder();
								if (this.result.hasTransparent)
								{
									builder2.MergeFrom(this.Transparent);
								}
								input.ReadMessage(builder2, extensionRegistry);
								this.Transparent = builder2.BuildPartial();
								continue;
							}
						}
					}
					else if (num <= 48u)
					{
						if (num == 42u)
						{
							this.result.hasExtraData = input.ReadString(ref this.result.extraData_);
							continue;
						}
						if (num == 48u)
						{
							this.result.hasMsgType = input.ReadInt32(ref this.result.msgType_);
							continue;
						}
					}
					else
					{
						if (num == 56u)
						{
							this.result.hasMsgTraceFlag = input.ReadInt32(ref this.result.msgTraceFlag_);
							continue;
						}
						if (num == 64u)
						{
							this.result.hasPriority = input.ReadInt32(ref this.result.priority_);
							continue;
						}
					}
					if (WireFormat.IsEndGroupTag(num))
					{
						if (builder != null)
						{
							this.UnknownFields = builder.Build();
						}
						return this;
					}
					if (builder == null)
					{
						builder = UnknownFieldSet.CreateBuilder(this.UnknownFields);
					}
					this.ParseUnknownField(input, builder, extensionRegistry, num, text);
				}
				if (builder != null)
				{
					this.UnknownFields = builder.Build();
				}
				return this;
			}

			// Token: 0x1700034B RID: 843
			// (get) Token: 0x06000838 RID: 2104 RVA: 0x0001387B File Offset: 0x00011A7B
			public bool HasIsOffline
			{
				get
				{
					return this.result.hasIsOffline;
				}
			}

			// Token: 0x1700034C RID: 844
			// (get) Token: 0x06000839 RID: 2105 RVA: 0x00013888 File Offset: 0x00011A88
			// (set) Token: 0x0600083A RID: 2106 RVA: 0x00013895 File Offset: 0x00011A95
			public bool IsOffline
			{
				get
				{
					return this.result.IsOffline;
				}
				set
				{
					this.SetIsOffline(value);
				}
			}

			// Token: 0x0600083B RID: 2107 RVA: 0x0001389F File Offset: 0x00011A9F
			public OSMessage.Builder SetIsOffline(bool value)
			{
				this.PrepareBuilder();
				this.result.hasIsOffline = true;
				this.result.isOffline_ = value;
				return this;
			}

			// Token: 0x0600083C RID: 2108 RVA: 0x000138C1 File Offset: 0x00011AC1
			public OSMessage.Builder ClearIsOffline()
			{
				this.PrepareBuilder();
				this.result.hasIsOffline = false;
				this.result.isOffline_ = false;
				return this;
			}

			// Token: 0x1700034D RID: 845
			// (get) Token: 0x0600083D RID: 2109 RVA: 0x000138E3 File Offset: 0x00011AE3
			public bool HasOfflineExpireTime
			{
				get
				{
					return this.result.hasOfflineExpireTime;
				}
			}

			// Token: 0x1700034E RID: 846
			// (get) Token: 0x0600083E RID: 2110 RVA: 0x000138F0 File Offset: 0x00011AF0
			// (set) Token: 0x0600083F RID: 2111 RVA: 0x000138FD File Offset: 0x00011AFD
			public long OfflineExpireTime
			{
				get
				{
					return this.result.OfflineExpireTime;
				}
				set
				{
					this.SetOfflineExpireTime(value);
				}
			}

			// Token: 0x06000840 RID: 2112 RVA: 0x00013907 File Offset: 0x00011B07
			public OSMessage.Builder SetOfflineExpireTime(long value)
			{
				this.PrepareBuilder();
				this.result.hasOfflineExpireTime = true;
				this.result.offlineExpireTime_ = value;
				return this;
			}

			// Token: 0x06000841 RID: 2113 RVA: 0x00013929 File Offset: 0x00011B29
			public OSMessage.Builder ClearOfflineExpireTime()
			{
				this.PrepareBuilder();
				this.result.hasOfflineExpireTime = false;
				this.result.offlineExpireTime_ = 1L;
				return this;
			}

			// Token: 0x1700034F RID: 847
			// (get) Token: 0x06000842 RID: 2114 RVA: 0x0001394C File Offset: 0x00011B4C
			public bool HasTransparent
			{
				get
				{
					return this.result.hasTransparent;
				}
			}

			// Token: 0x17000350 RID: 848
			// (get) Token: 0x06000843 RID: 2115 RVA: 0x00013959 File Offset: 0x00011B59
			// (set) Token: 0x06000844 RID: 2116 RVA: 0x00013966 File Offset: 0x00011B66
			public Transparent Transparent
			{
				get
				{
					return this.result.Transparent;
				}
				set
				{
					this.SetTransparent(value);
				}
			}

			// Token: 0x06000845 RID: 2117 RVA: 0x00013970 File Offset: 0x00011B70
			public OSMessage.Builder SetTransparent(Transparent value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.hasTransparent = true;
				this.result.transparent_ = value;
				return this;
			}

			// Token: 0x06000846 RID: 2118 RVA: 0x0001399D File Offset: 0x00011B9D
			public OSMessage.Builder SetTransparent(Transparent.Builder builderForValue)
			{
				ThrowHelper.ThrowIfNull(builderForValue, "builderForValue");
				this.PrepareBuilder();
				this.result.hasTransparent = true;
				this.result.transparent_ = builderForValue.Build();
				return this;
			}

			// Token: 0x06000847 RID: 2119 RVA: 0x000139D0 File Offset: 0x00011BD0
			public OSMessage.Builder MergeTransparent(Transparent value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				if (this.result.hasTransparent && this.result.transparent_ != Transparent.DefaultInstance)
				{
					this.result.transparent_ = Transparent.CreateBuilder(this.result.transparent_).MergeFrom(value).BuildPartial();
				}
				else
				{
					this.result.transparent_ = value;
				}
				this.result.hasTransparent = true;
				return this;
			}

			// Token: 0x06000848 RID: 2120 RVA: 0x00013A4F File Offset: 0x00011C4F
			public OSMessage.Builder ClearTransparent()
			{
				this.PrepareBuilder();
				this.result.hasTransparent = false;
				this.result.transparent_ = null;
				return this;
			}

			// Token: 0x17000351 RID: 849
			// (get) Token: 0x06000849 RID: 2121 RVA: 0x00013A71 File Offset: 0x00011C71
			public bool HasExtraData
			{
				get
				{
					return this.result.hasExtraData;
				}
			}

			// Token: 0x17000352 RID: 850
			// (get) Token: 0x0600084A RID: 2122 RVA: 0x00013A7E File Offset: 0x00011C7E
			// (set) Token: 0x0600084B RID: 2123 RVA: 0x00013A8B File Offset: 0x00011C8B
			public string ExtraData
			{
				get
				{
					return this.result.ExtraData;
				}
				set
				{
					this.SetExtraData(value);
				}
			}

			// Token: 0x0600084C RID: 2124 RVA: 0x00013A95 File Offset: 0x00011C95
			public OSMessage.Builder SetExtraData(string value)
			{
				ThrowHelper.ThrowIfNull(value, "value");
				this.PrepareBuilder();
				this.result.hasExtraData = true;
				this.result.extraData_ = value;
				return this;
			}

			// Token: 0x0600084D RID: 2125 RVA: 0x00013AC2 File Offset: 0x00011CC2
			public OSMessage.Builder ClearExtraData()
			{
				this.PrepareBuilder();
				this.result.hasExtraData = false;
				this.result.extraData_ = "";
				return this;
			}

			// Token: 0x17000353 RID: 851
			// (get) Token: 0x0600084E RID: 2126 RVA: 0x00013AE8 File Offset: 0x00011CE8
			public bool HasMsgType
			{
				get
				{
					return this.result.hasMsgType;
				}
			}

			// Token: 0x17000354 RID: 852
			// (get) Token: 0x0600084F RID: 2127 RVA: 0x00013AF5 File Offset: 0x00011CF5
			// (set) Token: 0x06000850 RID: 2128 RVA: 0x00013B02 File Offset: 0x00011D02
			public int MsgType
			{
				get
				{
					return this.result.MsgType;
				}
				set
				{
					this.SetMsgType(value);
				}
			}

			// Token: 0x06000851 RID: 2129 RVA: 0x00013B0C File Offset: 0x00011D0C
			public OSMessage.Builder SetMsgType(int value)
			{
				this.PrepareBuilder();
				this.result.hasMsgType = true;
				this.result.msgType_ = value;
				return this;
			}

			// Token: 0x06000852 RID: 2130 RVA: 0x00013B2E File Offset: 0x00011D2E
			public OSMessage.Builder ClearMsgType()
			{
				this.PrepareBuilder();
				this.result.hasMsgType = false;
				this.result.msgType_ = 0;
				return this;
			}

			// Token: 0x17000355 RID: 853
			// (get) Token: 0x06000853 RID: 2131 RVA: 0x00013B50 File Offset: 0x00011D50
			public bool HasMsgTraceFlag
			{
				get
				{
					return this.result.hasMsgTraceFlag;
				}
			}

			// Token: 0x17000356 RID: 854
			// (get) Token: 0x06000854 RID: 2132 RVA: 0x00013B5D File Offset: 0x00011D5D
			// (set) Token: 0x06000855 RID: 2133 RVA: 0x00013B6A File Offset: 0x00011D6A
			public int MsgTraceFlag
			{
				get
				{
					return this.result.MsgTraceFlag;
				}
				set
				{
					this.SetMsgTraceFlag(value);
				}
			}

			// Token: 0x06000856 RID: 2134 RVA: 0x00013B74 File Offset: 0x00011D74
			public OSMessage.Builder SetMsgTraceFlag(int value)
			{
				this.PrepareBuilder();
				this.result.hasMsgTraceFlag = true;
				this.result.msgTraceFlag_ = value;
				return this;
			}

			// Token: 0x06000857 RID: 2135 RVA: 0x00013B96 File Offset: 0x00011D96
			public OSMessage.Builder ClearMsgTraceFlag()
			{
				this.PrepareBuilder();
				this.result.hasMsgTraceFlag = false;
				this.result.msgTraceFlag_ = 0;
				return this;
			}

			// Token: 0x17000357 RID: 855
			// (get) Token: 0x06000858 RID: 2136 RVA: 0x00013BB8 File Offset: 0x00011DB8
			public bool HasPriority
			{
				get
				{
					return this.result.hasPriority;
				}
			}

			// Token: 0x17000358 RID: 856
			// (get) Token: 0x06000859 RID: 2137 RVA: 0x00013BC5 File Offset: 0x00011DC5
			// (set) Token: 0x0600085A RID: 2138 RVA: 0x00013BD2 File Offset: 0x00011DD2
			public int Priority
			{
				get
				{
					return this.result.Priority;
				}
				set
				{
					this.SetPriority(value);
				}
			}

			// Token: 0x0600085B RID: 2139 RVA: 0x00013BDC File Offset: 0x00011DDC
			public OSMessage.Builder SetPriority(int value)
			{
				this.PrepareBuilder();
				this.result.hasPriority = true;
				this.result.priority_ = value;
				return this;
			}

			// Token: 0x0600085C RID: 2140 RVA: 0x00013BFE File Offset: 0x00011DFE
			public OSMessage.Builder ClearPriority()
			{
				this.PrepareBuilder();
				this.result.hasPriority = false;
				this.result.priority_ = 0;
				return this;
			}

			// Token: 0x04000361 RID: 865
			private bool resultIsReadOnly;

			// Token: 0x04000362 RID: 866
			private OSMessage result;
		}
	}
}
